using System;
using System.Diagnostics;
using System.Text;
using Community.CsharpSqlite.Entity;

namespace Community.CsharpSqlite
{
    using sqlite3_value = Mem;


    public partial class Sqlite3
    {
        /*
    ** 2002 February 23
    **
    ** The author disclaims copyright to this source code.  In place of
    ** a legal notice, here is a blessing:
    **
    **    May you do good and not evil.
    **    May you find forgiveness for yourself and forgive others.
    **    May you share freely, never taking more than you give.
    **
    *************************************************************************
    ** This file contains the C functions that implement various SQL
    ** functions of SQLite.
    **
    ** There is only one exported symbol in this file - the function
    ** sqliteRegisterBuildinFunctions() found at the bottom of the file.
    ** All other code has file scope.
    *************************************************************************
    **  Included in SQLite3 port to C#-SQLite;  2008 Noah B Hart
    **  C#-SQLite is an independent reimplementation of the SQLite software library
    **
    **  SQLITE_SOURCE_ID: 2010-03-09 19:31:43 4ae453ea7be69018d8c16eb8dabe05617397dc4d
    **
    **  $Header: Community.CsharpSqlite/src/func_c.cs,v 6604176a7dbe 2010/03/12 23:35:36 Noah $
    *************************************************************************
    */
        //#include "sqliteInt.h"
        //#include <stdlib.h>
        //#include <assert.h>
        //#include "vdbeInt.h"


        /*
    ** Return the collating function associated with a function.
    */

        private static CollSeq sqlite3GetFuncCollSeq(sqlite3_context context)
        {
            return context.pColl;
        }

        /*
    ** Implementation of the non-aggregate min() and max() functions
    */

        private static void minmaxFunc(
            sqlite3_context context,
            int argc,
            sqlite3_value[] argv
            )
        {
            int i;
            int mask; /* 0 for min() or 0xffffffff for max() */
            int iBest;
            CollSeq pColl;

            Debug.Assert(argc > 1);
            mask = (int) sqlite3_user_data(context) == 0 ? 0 : -1;
            pColl = sqlite3GetFuncCollSeq(context);
            Debug.Assert(pColl != null);
            Debug.Assert(mask == -1 || mask == 0);
            UnitTest.TestCase(mask == 0);
            iBest = 0;
            if (sqlite3_value_type(argv[0]) == FundamentalDataType.SQLITE_NULL) return;
            for (i = 1; i < argc; i++)
            {
                if (sqlite3_value_type(argv[i]) == FundamentalDataType.SQLITE_NULL) return;
                if ((sqlite3MemCompare(argv[iBest], argv[i], pColl) ^ mask) >= 0)
                {
                    iBest = i;
                }
            }
            sqlite3_result_value(context, argv[iBest]);
        }

        /*
    ** Return the type of the argument.
    */

        private static void typeofFunc(
            sqlite3_context context,
            int NotUsed,
            sqlite3_value[] argv
            )
        {
            string z = "";
            Helper.UNUSED_PARAMETER(NotUsed);
            switch (sqlite3_value_type(argv[0]))
            {
                case FundamentalDataType.SQLITE_INTEGER:
                    z = "integer";
                    break;
                case FundamentalDataType.SQLITE_TEXT:
                    z = "text";
                    break;
                case FundamentalDataType.SQLITE_FLOAT:
                    z = "real";
                    break;
                case FundamentalDataType.SQLITE_BLOB:
                    z = "blob";
                    break;
                default:
                    z = "null";
                    break;
            }
            sqlite3_result_text(context, z, -1, Const.SQLITE_STATIC);
        }


        /*
    ** Implementation of the length() function
    */

        private static void lengthFunc(
            sqlite3_context context,
            int argc,
            sqlite3_value[] argv
            )
        {
            int len;

            Debug.Assert(argc == 1);
            Helper.UNUSED_PARAMETER(argc);
            switch (sqlite3_value_type(argv[0]))
            {
                case FundamentalDataType.SQLITE_BLOB:
                case FundamentalDataType.SQLITE_INTEGER:
                case FundamentalDataType.SQLITE_FLOAT:
                    {
                        sqlite3_result_int(context, sqlite3_value_bytes(argv[0]));
                        break;
                    }
                case FundamentalDataType.SQLITE_TEXT:
                    {
                        byte[] z = sqlite3_value_blob(argv[0]);
                        if (z == null) return;
                        len = 0;
                        int iz = 0;
                        while (iz < z.Length && z[iz] != '\0')
                        {
                            len++;
                            SQLITE_SKIP_UTF8(z, ref iz);
                        }
                        sqlite3_result_int(context, len);
                        break;
                    }
                default:
                    {
                        sqlite3_result_null(context);
                        break;
                    }
            }
        }

        /*
    ** Implementation of the abs() function.
    **
    ** IMP: R-23979-26855 The abs(X) function returns the absolute value of
    ** the numeric argument X. 
    */

        private static void absFunc(
            sqlite3_context context,
            int argc,
            sqlite3_value[] argv
            )
        {
            Debug.Assert(argc == 1);
            Helper.UNUSED_PARAMETER(argc);
            switch (sqlite3_value_type(argv[0]))
            {
                case FundamentalDataType.SQLITE_INTEGER:
                    {
                        long iVal = sqlite3_value_int64(argv[0]);
                        if (iVal < 0)
                        {
                            if ((iVal << 1) == 0)
                            {
                                /* IMP: R-35460-15084 If X is the integer -9223372036854775807 then
                ** abs(X) throws an integer overflow error since there is no
                ** equivalent positive 64-bit two complement value. */
                                sqlite3_result_error(context, "integer overflow", -1);
                                return;
                            }
                            iVal = -iVal;
                        }
                        sqlite3_result_int64(context, iVal);
                        break;
                    }
                case FundamentalDataType.SQLITE_NULL:
                    {
                        /* IMP: R-37434-19929 Abs(X) returns NULL if X is NULL. */
                        sqlite3_result_null(context);
                        break;
                    }
                default:
                    {
                        /* Because sqlite3_value_double() returns 0.0 if the argument is not
            ** something that can be converted into a number, we have:
            ** IMP: R-57326-31541 Abs(X) return 0.0 if X is a string or blob that
            ** cannot be converted to a numeric value. 
            */
                        double rVal = sqlite3_value_double(argv[0]);
                        if (rVal < 0) rVal = -rVal;
                        sqlite3_result_double(context, rVal);
                        break;
                    }
            }
        }

        /*
    ** Implementation of the substr() function.
    **
    ** substr(x,p1,p2)  returns p2 characters of x[] beginning with p1.
    ** p1 is 1-indexed.  So substr(x,1,1) returns the first character
    ** of x.  If x is text, then we actually count UTF-8 characters.
    ** If x is a blob, then we count bytes.
    **
    ** If p1 is negative, then we begin abs(p1) from the end of x[].
    **
    ** If p2 is negative, return the p2 characters preceeding p1.
    */

        private static void substrFunc(
            sqlite3_context context,
            int argc,
            sqlite3_value[] argv
            )
        {
            string z = "";
            byte[] zBLOB = null;
            string z2;
            int len;
            int p0type;
            int p1, p2;
            int negP2 = 0;

            Debug.Assert(argc == 3 || argc == 2);
            if (sqlite3_value_type(argv[1]) == FundamentalDataType.SQLITE_NULL
                || (argc == 3 && sqlite3_value_type(argv[2]) == FundamentalDataType.SQLITE_NULL)
                )
            {
                return;
            }
            p0type = sqlite3_value_type(argv[0]);
            p1 = sqlite3_value_int(argv[1]);
            if (p0type == FundamentalDataType.SQLITE_BLOB)
            {
                len = sqlite3_value_bytes(argv[0]);
                zBLOB = argv[0].zBLOB;
                if (zBLOB == null) return;
                Debug.Assert(len == zBLOB.Length);
            }
            else
            {
                z = sqlite3_value_text(argv[0]);
                if (String.IsNullOrEmpty(z)) return;
                len = 0;
                if (p1 < 0)
                {
                    len = z.Length;
                    //for ( z2 = z ; z2 != "" ; len++ )
                    //{
                    //  SQLITE_SKIP_UTF8( ref z2 );
                    //}
                }
            }
            if (argc == 3)
            {
                p2 = sqlite3_value_int(argv[2]);
                if (p2 < 0)
                {
                    p2 = -p2;
                    negP2 = 1;
                }
            }
            else
            {
                p2 = (sqlite3_context_db_handle(context)).aLimit[LimitCategory.SQLITE_LIMIT_LENGTH];
            }
            if (p1 < 0)
            {
                p1 += len;
                if (p1 < 0)
                {
                    p2 += p1;
                    if (p2 < 0) p2 = 0;
                    p1 = 0;
                }
            }
            else if (p1 > 0)
            {
                p1--;
            }
            else if (p2 > 0)
            {
                p2--;
            }
            if (negP2 != 0)
            {
                p1 -= p2;
                if (p1 < 0)
                {
                    p2 += p1;
                    p1 = 0;
                }
            }
            Debug.Assert(p1 >= 0 && p2 >= 0);
            if (p0type != FundamentalDataType.SQLITE_BLOB)
            {
                //while ( z != "" && p1 != 0 )
                //{
                //  SQLITE_SKIP_UTF8( ref z );
                //  p1--;
                //}
                //for ( z2 = z ; z2 != "" && p2 != 0 ; p2-- )
                //{
                //  SQLITE_SKIP_UTF8( ref z2 );
                //}
                sqlite3_result_text(context, z, p1, p2 <= z.Length - p1 ? p2 : z.Length - p1, Const.SQLITE_TRANSIENT);
            }
            else
            {
                if (p1 + p2 > len)
                {
                    p2 = len - p1;
                    if (p2 < 0) p2 = 0;
                }
                var sb = new StringBuilder(zBLOB.Length);
                if (zBLOB.Length == 0 || p1 > zBLOB.Length) sb.Length = 0;
                else
                {
                    for (int i = p1; i < p1 + p2; i++)
                    {
                        sb.Append((char) zBLOB[i]);
                    }
                }

                sqlite3_result_blob(context, sb.ToString(), p2, Const.SQLITE_TRANSIENT);
            }
        }

        /*
    ** Implementation of the round() function
    */
#if !SQLITE_OMIT_FLOATING_POINT
        private static void roundFunc(
            sqlite3_context context,
            int argc,
            sqlite3_value[] argv
            )
        {
            int n = 0;
            double r;
            string zBuf = "";
            Debug.Assert(argc == 1 || argc == 2);
            if (argc == 2)
            {
                if (FundamentalDataType.SQLITE_NULL == sqlite3_value_type(argv[1])) return;
                n = sqlite3_value_int(argv[1]);
                if (n > 30) n = 30;
                if (n < 0) n = 0;
            }
            if (sqlite3_value_type(argv[0]) == FundamentalDataType.SQLITE_NULL) return;
            r = sqlite3_value_double(argv[0]);
            /* If Y==0 and X will fit in a 64-bit int,
      ** handle the rounding directly,
      ** otherwise use Custom.Printf.
      */
            if (n == 0 && r >= 0 && r < Const.LARGEST_INT64 - 1)
            {
                r = ((long) (r + 0.5));
            }
            else if (n == 0 && r < 0 && (-r) < Const.LARGEST_INT64 - 1)
            {
                r = -(double) ((long) ((-r) + 0.5));
            }
            else
            {
                zBuf = Print.Sqlite3_mprintf("%.*f", n, r);
                if (zBuf == null)
                {
                    sqlite3_result_error_nomem(context);
                    return;
                }
                Utility.Sqlite3AtoF(zBuf, ref r);
                //Malloc.sqlite3_free( ref zBuf );
            }
            sqlite3_result_double(context, r);
        }
#endif

        /*
** Allocate nByte bytes of space using Malloc.sqlite3_malloc(). If the
** allocation fails, call sqlite3_result_error_nomem() to notify
** the database handle that malloc() has failed and return NULL.
** If nByte is larger than the maximum string or blob length, then
** raise an StatusCode.SQLITE_TOOBIG exception and return NULL.
*/
        //static void* contextMalloc( sqlite3_context* context, long nByte )
        //{
        //  char* z;
        //  sqlite3* db = sqlite3_context_db_handle( context );
        //  assert( nByte > 0 );
        //  UnitTest.TestCase( nByte == db->aLimit[LimitCategory.SQLITE_LIMIT_LENGTH] );
        //  UnitTest.TestCase( nByte == db->aLimit[LimitCategory.SQLITE_LIMIT_LENGTH] + 1 );
        //  if ( nByte > db->aLimit[LimitCategory.SQLITE_LIMIT_LENGTH] )
        //  {
        //    sqlite3_result_error_toobig( context );
        //    z = 0;
        //  }
        //  else
        //  {
        //    z = Malloc.sqlite3Malloc( (int)nByte );
        //    if ( !z )
        //    {
        //      sqlite3_result_error_nomem( context );
        //    }
        //  }
        //  return z;
        //}

        /*
    ** Implementation of the upper() and lower() SQL functions.
    */

        private static void upperFunc(
            sqlite3_context context,
            int argc,
            sqlite3_value[] argv
            )
        {
            string z1;
            string z2;
            int i, n;
            Helper.UNUSED_PARAMETER(argc);
            z2 = sqlite3_value_text(argv[0]);
            n = sqlite3_value_bytes(argv[0]);
            /* Verify that the call to _bytes() does not invalidate the _text() pointer */
            //Debug.Assert( z2 == sqlite3_value_text( argv[0] ) );
            if (z2 != null)
            {
                //z1 = new byte[n];// contextMalloc(context, ((long)n)+1);
                //if ( z1 !=null)
                //{
                //  memcpy( z1, z2, n + 1 );
                //for ( i = 0 ; i< z1.Length ; i++ )
                //{
                //(char)sqlite3Toupper( z1[i] );
                //}
                sqlite3_result_text(context, z2.Length == 0 ? "" : z2.Substring(0, n).ToUpper(), -1, null);
                    //Malloc.sqlite3_free );
                // }
            }
        }

        private static void lowerFunc(
            sqlite3_context context,
            int argc,
            sqlite3_value[] argv
            )
        {
            string z1;
            string z2;
            int i, n;
            Helper.UNUSED_PARAMETER(argc);
            z2 = sqlite3_value_text(argv[0]);
            n = sqlite3_value_bytes(argv[0]);
            /* Verify that the call to _bytes() does not invalidate the _text() pointer */
            //Debug.Assert( z2 == sqlite3_value_text( argv[0] ) );
            if (z2 != null)
            {
                //z1 = contextMalloc(context, ((long)n)+1);
                //if ( z1 )
                //{
                //  memcpy( z1, z2, n + 1 );
                //  for ( i = 0 ; z1[i] ; i++ )
                //  {
                //    z1[i] = (char)sqlite3Tolower( z1[i] );
                //  }
                sqlite3_result_text(context, z2.Length == 0 ? "" : z2.Substring(0, n).ToLower(), -1, null);
                    //Malloc.sqlite3_free );
                //}
            }
        }

#if FALSE //* This function is never used. */
/*
** The COALESCE() and IFNULL() functions used to be implemented as shown
** here.  But now they are implemented as VDBE code so that unused arguments
** do not have to be computed.  This legacy implementation is retained as
** comment.
*/
/*
** Implementation of the IFNULL(), NVL(), and COALESCE() functions.
** All three do the same thing.  They return the first non-NULL
** argument.
*/
static void ifnullFunc(
sqlite3_context context,
int argc,
sqlite3_value[] argv
)
{
int i;
for ( i = 0 ; i < argc ; i++ )
{
if ( FundamentalDataType.SQLITE_NULL != sqlite3_value_type( argv[i] ) )
{
sqlite3_result_value( context, argv[i] );
break;
}
}
}
#endif
        //* NOT USED */
        //#define ifnullFunc versionFunc   /* Substitute function - never called */

        /*
    ** Implementation of random().  Return a random integer.
    */

        private static void randomFunc(
            sqlite3_context context,
            int NotUsed,
            sqlite3_value[] NotUsed2
            )
        {
            long r = 0;
            Helper.UNUSED_PARAMETER2(NotUsed, NotUsed2);
            Random.Randomness(sizeof (long), ref r);
            if (r < 0)
            {
                /* We need to prevent a random number of 0x8000000000000000
        ** (or -9223372036854775808) since when you do abs() of that
        ** number of you get the same value back again.  To do this
        ** in a way that is testable, mask the sign bit off of negative
        ** values, resulting in a positive value.  Then take the
        ** 2s complement of that positive value.  The end result can
        ** therefore be no less than -9223372036854775807.
        */
                r = -(r ^ (((long) 1) << 63));
            }
            sqlite3_result_int64(context, r);
        }

        /*
    ** Implementation of randomblob(N).  Return a random blob
    ** that is N bytes long.
    */

        private static void randomBlob(
            sqlite3_context context,
            int argc,
            sqlite3_value[] argv
            )
        {
            int n;
            char[] p;
            Debug.Assert(argc == 1);
            Helper.UNUSED_PARAMETER(argc);
            n = sqlite3_value_int(argv[0]);
            if (n < 1)
            {
                n = 1;
            }
            p = new char[n]; //contextMalloc( context, n );
            if (p != null)
            {
                long _p = 0;
                for (int i = 0; i < n; i++)
                {
                    Random.Randomness(sizeof (byte), ref _p);
                    p[i] = (char) (_p & 0x7F);
                }
                sqlite3_result_blob(context, new string(p), n, null); //Malloc.sqlite3_free );
            }
        }

        /*
    ** Implementation of the last_insert_rowid() SQL function.  The return
    ** value is the same as the sqlite3_last_insert_rowid() API function.
    */

        private static void last_insert_rowid(
            sqlite3_context context,
            int NotUsed,
            sqlite3_value[] NotUsed2
            )
        {
            sqlite3 db = sqlite3_context_db_handle(context);
            Helper.UNUSED_PARAMETER2(NotUsed, NotUsed2);
            /* IMP: R-51513-12026 The last_insert_rowid() SQL function is a
      ** wrapper around the sqlite3_last_insert_rowid() C/C++ interface
      ** function. */
            sqlite3_result_int64(context, sqlite3_last_insert_rowid(db));
        }

        /*
    ** Implementation of the changes() SQL function.
    **
    ** IMP: R-62073-11209 The changes() SQL function is a wrapper
    ** around the sqlite3_changes() C/C++ function and hence follows the same
    ** rules for counting changes.
    */

        private static void changes(
            sqlite3_context context,
            int NotUsed,
            sqlite3_value[] NotUsed2
            )
        {
            sqlite3 db = sqlite3_context_db_handle(context);
            Helper.UNUSED_PARAMETER2(NotUsed, NotUsed2);
            sqlite3_result_int(context, sqlite3_changes(db));
        }

        /*
    ** Implementation of the total_changes() SQL function.  The return value is
    ** the same as the sqlite3_total_changes() API function.
    */

        private static void total_changes(
            sqlite3_context context,
            int NotUsed,
            sqlite3_value[] NotUsed2
            )
        {
            sqlite3 db = sqlite3_context_db_handle(context);
            Helper.UNUSED_PARAMETER2(NotUsed, NotUsed2);
            /* IMP: R-52756-41993 This function is a wrapper around the
      ** sqlite3_total_changes() C/C++ interface. */
            sqlite3_result_int(context, sqlite3_total_changes(db));
        }

        /*
    ** A structure defining how to do GLOB-style comparisons.
    */

        private struct compareInfo
        {
            public readonly char matchAll;
            public readonly char matchOne;
            public readonly char matchSet;
            public readonly bool noCase;

            public compareInfo(char matchAll, char matchOne, char matchSet, bool noCase)
            {
                this.matchAll = matchAll;
                this.matchOne = matchOne;
                this.matchSet = matchSet;
                this.noCase = noCase;
            }
        };

        /*
    ** For LIKE and GLOB matching on EBCDIC machines, assume that every
    ** character is exactly one byte in size.  Also, all characters are
    ** able to participate in upper-case-to-lower-case mappings in EBCDIC
    ** whereas only characters less than 0x80 do in ASCII.
    */
#if (SQLITE_EBCDIC)
//# define UtfHelper.Utf8Read(A,C)    (*(A++))
//# define GlogUpperToLower(A)     A = Global.Sqlite3UpperToLower[A]
#else
        //# define GlogUpperToLower(A)     if( A<0x80 ){ A = Global.Sqlite3UpperToLower[A]; }
#endif

        private static readonly compareInfo globInfo = new compareInfo('*', '?', '[', false);
        /* The correct SQL-92 behavior is for the LIKE operator to ignore
    ** case.  Thus  'a' LIKE 'A' would be true. */
        private static readonly compareInfo likeInfoNorm = new compareInfo('%', '_', '\0', true);
        /* If SQLITE_CASE_SENSITIVE_LIKE is defined, then the LIKE operator
    ** is case sensitive causing 'a' LIKE 'A' to be false */
        private static readonly compareInfo likeInfoAlt = new compareInfo('%', '_', '\0', false);

        /*
    ** Compare two UTF-8 strings for equality where the first string can
    ** potentially be a "glob" expression.  Return true (1) if they
    ** are the same and false (0) if they are different.
    **
    ** Globbing rules:
    **
    **      '*'       Matches any sequence of zero or more characters.
    **
    **      '?'       Matches exactly one character.
    **
    **     [...]      Matches one character from the enclosed list of
    **                characters.
    **
    **     [^...]     Matches one character not in the enclosed list.
    **
    ** With the [...] and [^...] matching, a ']' character can be included
    ** in the list by making it the first character after '[' or '^'.  A
    ** range of characters can be specified using '-'.  Example:
    ** "[a-z]" matches any single lower-case letter.  To match a '-', make
    ** it the last character in the list.
    **
    ** This routine is usually quick, but can be N**2 in the worst case.
    **
    ** Hints: to match '*' or '?', put them in "[]".  Like this:
    **
    **         abc[*]xyz        Matches "abc*xyz" only
    */

        private static bool patternCompare(
            string zPattern, /* The glob pattern */
            string zString, /* The string to compare against the glob */
            compareInfo pInfo, /* Information about how to do the compare */
            int esc /* The escape character */
            )
        {
            int c, c2;
            int invert;
            int seen;
            int matchOne = pInfo.matchOne;
            int matchAll = pInfo.matchAll;
            int matchSet = pInfo.matchSet;
            bool noCase = pInfo.noCase;
            bool prevEscape = false; /* True if the previous character was 'escape' */
            string inPattern = zPattern; //Entered Pattern

            while ((c = UtfHelper.Utf8Read(zPattern, ref zPattern)) != 0)
            {
                if (!prevEscape && c == matchAll)
                {
                    while ((c = UtfHelper.Utf8Read(zPattern, ref zPattern)) == matchAll
                           || c == matchOne)
                    {
                        if (c == matchOne && UtfHelper.Utf8Read(zString, ref zString) == 0)
                        {
                            return false;
                        }
                    }
                    if (c == 0)
                    {
                        return true;
                    }
                    else if (c == esc)
                    {
                        c = UtfHelper.Utf8Read(zPattern, ref zPattern);
                        if (c == 0)
                        {
                            return false;
                        }
                    }
                    else if (c == matchSet)
                    {
                        Debug.Assert(esc == 0); /* This is GLOB, not LIKE */
                        Debug.Assert(matchSet < 0x80); /* '[' is a single-byte character */
                        int len = 0;
                        while (len < zString.Length &&
                               patternCompare(inPattern.Substring(inPattern.Length - zPattern.Length - 1),
                                              zString.Substring(len), pInfo, esc) == false)
                        {
                            SQLITE_SKIP_UTF8(zString, ref len);
                        }
                        return len < zString.Length;
                    }
                    while ((c2 = UtfHelper.Utf8Read(zString, ref zString)) != 0)
                    {
                        if (noCase)
                        {
                            if (c2 < 0x80) c2 = Global.Sqlite3UpperToLower[c2]; //GlogUpperToLower(c2);
                            if (c < 0x80) c = Global.Sqlite3UpperToLower[c]; //GlogUpperToLower(c);
                            while (c2 != 0 && c2 != c)
                            {
                                c2 = UtfHelper.Utf8Read(zString, ref zString);
                                if (c2 < 0x80) c2 = Global.Sqlite3UpperToLower[c2]; //GlogUpperToLower(c2);
                            }
                        }
                        else
                        {
                            while (c2 != 0 && c2 != c)
                            {
                                c2 = UtfHelper.Utf8Read(zString, ref zString);
                            }
                        }
                        if (c2 == 0) return false;
                        if (patternCompare(zPattern, zString, pInfo, esc)) return true;
                    }
                    return false;
                }
                else if (!prevEscape && c == matchOne)
                {
                    if (UtfHelper.Utf8Read(zString, ref zString) == 0)
                    {
                        return false;
                    }
                }
                else if (c == matchSet)
                {
                    int prior_c = 0;
                    Debug.Assert(esc == 0); /* This only occurs for GLOB, not LIKE */
                    seen = 0;
                    invert = 0;
                    c = UtfHelper.Utf8Read(zString, ref zString);
                    if (c == 0) return false;
                    c2 = UtfHelper.Utf8Read(zPattern, ref zPattern);
                    if (c2 == '^')
                    {
                        invert = 1;
                        c2 = UtfHelper.Utf8Read(zPattern, ref zPattern);
                    }
                    if (c2 == ']')
                    {
                        if (c == ']') seen = 1;
                        c2 = UtfHelper.Utf8Read(zPattern, ref zPattern);
                    }
                    while (c2 != 0 && c2 != ']')
                    {
                        if (c2 == '-' && zPattern[0] != ']' && zPattern[0] != 0 && prior_c > 0)
                        {
                            c2 = UtfHelper.Utf8Read(zPattern, ref zPattern);
                            if (c >= prior_c && c <= c2) seen = 1;
                            prior_c = 0;
                        }
                        else
                        {
                            if (c == c2)
                            {
                                seen = 1;
                            }
                            prior_c = c2;
                        }
                        c2 = UtfHelper.Utf8Read(zPattern, ref zPattern);
                    }
                    if (c2 == 0 || (seen ^ invert) == 0)
                    {
                        return false;
                    }
                }
                else if (esc == c && !prevEscape)
                {
                    prevEscape = true;
                }
                else
                {
                    c2 = UtfHelper.Utf8Read(zString, ref zString);
                    if (noCase)
                    {
                        if (c < 0x80) c = Global.Sqlite3UpperToLower[c]; //GlogUpperToLower(c);
                        if (c2 < 0x80) c2 = Global.Sqlite3UpperToLower[c2]; //GlogUpperToLower(c2);
                    }
                    if (c != c2)
                    {
                        return false;
                    }
                    prevEscape = false;
                }
            }
            return zString.Length == 0;
        }

        /*
    ** Count the number of times that the LIKE operator (or GLOB which is
    ** just a variation of LIKE) gets called.  This is used for testing
    ** only.
    */
#if SQLITE_TEST
    //static int sqlite3_like_count = 0;
#endif


        /*
** Implementation of the like() SQL function.  This function implements
** the build-in LIKE operator.  The first argument to the function is the
** pattern and the second argument is the string.  So, the SQL statements:
**
**       A LIKE B
**
** is implemented as like(B,A).
**
** This same function (with a different compareInfo structure) computes
** the GLOB operator.
*/

        private static void likeFunc(
            sqlite3_context context,
            int argc,
            sqlite3_value[] argv
            )
        {
            string zA, zB;
            int escape = 0;
            int nPat;
            sqlite3 db = sqlite3_context_db_handle(context);

            zB = sqlite3_value_text(argv[0]);
            zA = sqlite3_value_text(argv[1]);

            /* Limit the length of the LIKE or GLOB pattern to avoid problems
      ** of deep recursion and N*N behavior in patternCompare().
      */
            nPat = sqlite3_value_bytes(argv[0]);
            UnitTest.TestCase(nPat == db.aLimit[LimitCategory.SQLITE_LIMIT_LIKE_PATTERN_LENGTH]);
            UnitTest.TestCase(nPat == db.aLimit[LimitCategory.SQLITE_LIMIT_LIKE_PATTERN_LENGTH] + 1);
            if (nPat > db.aLimit[LimitCategory.SQLITE_LIMIT_LIKE_PATTERN_LENGTH])
            {
                sqlite3_result_error(context, "LIKE or GLOB pattern too complex", -1);
                return;
            }
            //Debug.Assert( zB == sqlite3_value_text( argv[0] ) );  /* Encoding did not change */

            if (argc == 3)
            {
                /* The escape character string must consist of a single UTF-8 character.
        ** Otherwise, return an error.
        */
                string zEsc = sqlite3_value_text(argv[2]);
                if (zEsc == null) return;
                if (UtfHelper.Utf8CharLen(zEsc, -1) != 1)
                {
                    sqlite3_result_error(context,
                                         "ESCAPE expression must be a single character", -1);
                    return;
                }
                escape = UtfHelper.Utf8Read(zEsc, ref zEsc);
            }
            if (zA != null && zB != null)
            {
                var pInfo = (compareInfo) sqlite3_user_data(context);
#if SQLITE_TEST
        sqlite3_like_count.iValue++;
#endif
                sqlite3_result_int(context, patternCompare(zB, zA, pInfo, escape) ? 1 : 0);
            }
        }

        /*
    ** Implementation of the NULLIF(x,y) function.  The result is the first
    ** argument if the arguments are different.  The result is NULL if the
    ** arguments are equal to each other.
    */

        private static void nullifFunc(
            sqlite3_context context,
            int NotUsed,
            sqlite3_value[] argv
            )
        {
            CollSeq pColl = sqlite3GetFuncCollSeq(context);
            Helper.UNUSED_PARAMETER(NotUsed);
            if (sqlite3MemCompare(argv[0], argv[1], pColl) != 0)
            {
                sqlite3_result_value(context, argv[0]);
            }
        }

        /*
    ** Implementation of the sqlite_version() function.  The result is the version
    ** of the SQLite library that is running.
    */

        private static void versionFunc(
            sqlite3_context context,
            int NotUsed,
            sqlite3_value[] NotUsed2
            )
        {
            Helper.UNUSED_PARAMETER2(NotUsed, NotUsed2);
            /* IMP: R-48699-48617 This function is an SQL wrapper around the
      ** sqlite3_libversion() C-interface. */
            sqlite3_result_text(context, sqlite3_libversion(), -1, Const.SQLITE_STATIC);
        }

        /*
    ** Implementation of the sqlite_source_id() function. The result is a string
    ** that identifies the particular version of the source code used to build
    ** SQLite.
    */

        private static void sourceidFunc(
            sqlite3_context context,
            int NotUsed,
            sqlite3_value[] NotUsed2
            )
        {
            Helper.UNUSED_PARAMETER2(NotUsed, NotUsed2);
            /* IMP: R-24470-31136 This function is an SQL wrapper around the
      ** sqlite3_sourceid() C interface. */
            sqlite3_result_text(context, sqlite3_sourceid(), -1, Const.SQLITE_STATIC);
        }

        /*
    ** Implementation of the sqlite_compileoption_used() function.
    ** The result is an integer that identifies if the compiler option
    ** was used to build SQLite.
    */
#if !SQLITE_OMIT_COMPILEOPTION_DIAGS
        private static void compileoptionusedFunc(
            sqlite3_context context,
            int argc,
            sqlite3_value[] argv
            )
        {
            string zOptName;
            Debug.Assert(argc == 1);
            Helper.UNUSED_PARAMETER(argc);
            /* IMP: R-xxxx This function is an SQL wrapper around the
      ** sqlite3_compileoption_used() C interface. */
            if ((zOptName = sqlite3_value_text(argv[0])) != null)
            {
                sqlite3_result_int(context, sqlite3_compileoption_used(zOptName));
            }
        }
#endif
        //* SQLITE_OMIT_COMPILEOPTION_DIAGS */


        /*
** Implementation of the sqlite_compileoption_get() function. 
** The result is a string that identifies the compiler options 
** used to build SQLite.
*/
#if !SQLITE_OMIT_COMPILEOPTION_DIAGS
        private static void compileoptiongetFunc(
            sqlite3_context context,
            int argc,
            sqlite3_value[] argv
            )
        {
            int n;
            Debug.Assert(argc == 1);
            Helper.UNUSED_PARAMETER(argc);
            /* IMP: R-xxxx This function is an SQL wrapper around the
      ** sqlite3_compileoption_get() C interface. */
            n = sqlite3_value_int(argv[0]);
            sqlite3_result_text(context, sqlite3_compileoption_get(n), -1, Const.SQLITE_STATIC);
        }
#endif
        //* SQLITE_OMIT_COMPILEOPTION_DIAGS */

        /* Array for converting from half-bytes (nybbles) into ASCII hex
** digits. */

        private static readonly char[] hexdigits = new[]
                                                       {
                                                           '0', '1', '2', '3', '4', '5', '6', '7',
                                                           '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'
                                                       };

        /*
    ** EXPERIMENTAL - This is not an official function.  The interface may
    ** change.  This function may disappear.  Do not write code that depends
    ** on this function.
    **
    ** Implementation of the QUOTE() function.  This function takes a single
    ** argument.  If the argument is numeric, the return value is the same as
    ** the argument.  If the argument is NULL, the return value is the string
    ** "NULL".  Otherwise, the argument is enclosed in single quotes with
    ** single-quote escapes.
    */

        private static void quoteFunc(
            sqlite3_context context,
            int argc,
            sqlite3_value[] argv
            )
        {
            Debug.Assert(argc == 1);
            Helper.UNUSED_PARAMETER(argc);

            switch (sqlite3_value_type(argv[0]))
            {
                case FundamentalDataType.SQLITE_INTEGER:
                case FundamentalDataType.SQLITE_FLOAT:
                    {
                        sqlite3_result_value(context, argv[0]);
                        break;
                    }
                case FundamentalDataType.SQLITE_BLOB:
                    {
                        StringBuilder zText;
                        byte[] zBlob = sqlite3_value_blob(argv[0]);
                        int nBlob = sqlite3_value_bytes(argv[0]);
                        Debug.Assert(zBlob.Length == sqlite3_value_blob(argv[0]).Length); /* No encoding change */
                        zText = new StringBuilder(2*nBlob + 4); //(char*)contextMalloc(context, (2*(long)nBlob)+4);
                        zText.Append("X'");
                        if (zText != null)
                        {
                            int i;
                            for (i = 0; i < nBlob; i++)
                            {
                                zText.Append(hexdigits[(zBlob[i] >> 4) & 0x0F]);
                                zText.Append(hexdigits[(zBlob[i]) & 0x0F]);
                            }
                            zText.Append("'");
                            //zText[( nBlob * 2 ) + 2] = '\'';
                            //zText[( nBlob * 2 ) + 3] = '\0';
                            //zText[0] = 'X';
                            //zText[1] = '\'';
                            sqlite3_result_text(context, zText.ToString(), -1, Const.SQLITE_TRANSIENT);
                            //Malloc.sqlite3_free( ref  zText );
                        }
                        break;
                    }
                case FundamentalDataType.SQLITE_TEXT:
                    {
                        int i, j;
                        int n;
                        string zArg = sqlite3_value_text(argv[0]);
                        StringBuilder z;

                        if (zArg == null || zArg.Length == 0) return;
                        for (i = 0, n = 0; i < zArg.Length; i++)
                        {
                            if (zArg[i] == '\'') n++;
                        }
                        z = new StringBuilder(i + n + 3); // contextMalloc(context, ((long)i)+((long)n)+3);
                        if (z != null)
                        {
                            z.Append('\'');
                            for (i = 0, j = 1; i < zArg.Length && zArg[i] != 0; i++)
                            {
                                z.Append(zArg[i]);
                                j++;
                                if (zArg[i] == '\'')
                                {
                                    z.Append('\'');
                                    j++;
                                }
                            }
                            z.Append('\'');
                            j++;
                            //z[j] = '\0'; ;
                            sqlite3_result_text(context, z.ToString(), j, null); //Malloc.sqlite3_free );
                        }
                        break;
                    }
                default:
                    {
                        Debug.Assert(sqlite3_value_type(argv[0]) == FundamentalDataType.SQLITE_NULL);
                        sqlite3_result_text(context, "NULL", 4, Const.SQLITE_STATIC);
                        break;
                    }
            }
        }

        /*
    ** The hex() function.  Interpret the argument as a blob.  Return
    ** a hexadecimal rendering as text.
    */

        private static void hexFunc(
            sqlite3_context context,
            int argc,
            sqlite3_value[] argv
            )
        {
            int i, n;
            byte[] pBlob;
            //string zHex, z;
            Debug.Assert(argc == 1);
            Helper.UNUSED_PARAMETER(argc);
            pBlob = sqlite3_value_blob(argv[0]);
            n = sqlite3_value_bytes(argv[0]);
            Debug.Assert(n == pBlob.Length); /* No encoding change */
            var zHex = new StringBuilder(n*2 + 1);
            //  z = zHex = contextMalloc(context, ((long)n)*2 + 1);
            if (zHex != null)
            {
                for (i = 0; i < n; i++)
                {
//, pBlob++){
                    byte c = pBlob[i];
                    zHex.Append(hexdigits[(c >> 4) & 0xf]);
                    zHex.Append(hexdigits[c & 0xf]);
                }
                sqlite3_result_text(context, zHex.ToString(), n*2, null); //Malloc.sqlite3_free );
            }
        }

        /*
    ** The zeroblob(N) function returns a zero-filled blob of size N bytes.
    */

        private static void zeroblobFunc(
            sqlite3_context context,
            int argc,
            sqlite3_value[] argv
            )
        {
            long n;
            sqlite3 db = sqlite3_context_db_handle(context);
            Debug.Assert(argc == 1);
            Helper.UNUSED_PARAMETER(argc);
            n = sqlite3_value_int64(argv[0]);
            UnitTest.TestCase(n == db.aLimit[LimitCategory.SQLITE_LIMIT_LENGTH]);
            UnitTest.TestCase(n == db.aLimit[LimitCategory.SQLITE_LIMIT_LENGTH] + 1);
            if (n > db.aLimit[LimitCategory.SQLITE_LIMIT_LENGTH])
            {
                sqlite3_result_error_toobig(context);
            }
            else
            {
                sqlite3_result_zeroblob(context, (int) n); /* IMP: R-00293-64994 */
            }
        }

        /*
    ** The replace() function.  Three arguments are all strings: call
    ** them A, B, and C. The result is also a string which is derived
    ** from A by replacing every occurance of B with C.  The match
    ** must be exact.  Collating sequences are not used.
    */

        private static void replaceFunc(
            sqlite3_context context,
            int argc,
            sqlite3_value[] argv
            )
        {
            string zStr; /* The input string A */
            string zPattern; /* The pattern string B */
            string zRep; /* The replacement string C */
            string zOut; /* The output */
            int nStr; /* Size of zStr */
            int nPattern; /* Size of zPattern */
            int nRep; /* Size of zRep */
            int nOut; /* Maximum size of zOut */
            //int loopLimit;           /* Last zStr[] that might match zPattern[] */
            int i, j; /* Loop counters */

            Debug.Assert(argc == 3);
            Helper.UNUSED_PARAMETER(argc);
            zStr = sqlite3_value_text(argv[0]);
            if (zStr == null) return;
            nStr = sqlite3_value_bytes(argv[0]);
            Debug.Assert(zStr == sqlite3_value_text(argv[0])); /* No encoding change */
            zPattern = sqlite3_value_text(argv[1]);
            if (zPattern == null)
            {
                Debug.Assert(sqlite3_value_type(argv[1]) == FundamentalDataType.SQLITE_NULL
                    //|| sqlite3_context_db_handle( context ).mallocFailed != 0
                    );
                return;
            }
            if (zPattern == "")
            {
                Debug.Assert(sqlite3_value_type(argv[1]) != FundamentalDataType.SQLITE_NULL);
                sqlite3_result_value(context, argv[0]);
                return;
            }
            nPattern = sqlite3_value_bytes(argv[1]);
            Debug.Assert(zPattern == sqlite3_value_text(argv[1])); /* No encoding change */
            zRep = sqlite3_value_text(argv[2]);
            if (zRep == null) return;
            nRep = sqlite3_value_bytes(argv[2]);
            Debug.Assert(zRep == sqlite3_value_text(argv[2]));
            nOut = nStr + 1;
            Debug.Assert(nOut < SqliteLimit.SQLITE_MAX_LENGTH);
            //zOut = contextMalloc(context, (long)nOut);
            //if( zOut==0 ){
            //  return;
            //}
            //loopLimit = nStr - nPattern;
            //for(i=j=0; i<=loopLimit; i++){
            //  if( zStr[i]!=zPattern[0] || Custom.Memcmp(&zStr[i], zPattern, nPattern) ){
            //    zOut[j++] = zStr[i];
            //  }else{
            //    byte *zOld;
            // sqlite3 db = sqlite3_context_db_handle( context );
            //    nOut += nRep - nPattern;
            //UnitTest.TestCase( nOut-1==db->aLimit[LimitCategory.SQLITE_LIMIT_LENGTH] );
            //UnitTest.TestCase( nOut-2==db->aLimit[LimitCategory.SQLITE_LIMIT_LENGTH] );
            //if( nOut-1>db->aLimit[LimitCategory.SQLITE_LIMIT_LENGTH] ){
            //      sqlite3_result_error_toobig(context);
            //      MemPool.DbFree(db,ref  zOut);
            //      return;
            //    }
            //    zOld = zOut;
            //    zOut = Malloc.sqlite3_realloc(zOut, (int)nOut);
            //    if( zOut==0 ){
            //      sqlite3_result_error_nomem(context);
            //      MemPool.DbFree(db,ref  zOld);
            //      return;
            //    }
            //    memcpy(&zOut[j], zRep, nRep);
            //    j += nRep;
            //    i += nPattern-1;
            //  }
            //}
            //Debug.Assert( j+nStr-i+1==nOut );
            //memcpy(&zOut[j], zStr[i], nStr-i);
            //j += nStr - i;
            //Debug.Assert( j<=nOut );
            //zOut[j] = 0;
            zOut = zStr.Replace(zPattern, zRep);
            j = zOut.Length;
            sqlite3_result_text(context, zOut, j, null); //Malloc.sqlite3_free );
        }

        /*
    ** Implementation of the TRIM(), LTRIM(), and RTRIM() functions.
    ** The userdata is 0x1 for left trim, 0x2 for right trim, 0x3 for both.
    */

        private static void trimFunc(
            sqlite3_context context,
            int argc,
            sqlite3_value[] argv
            )
        {
            string zIn; /* Input string */
            string zCharSet; /* Set of characters to trim */
            int nIn; /* Number of bytes in input */
            int izIn = 0; /* C# string pointer */
            int flags; /* 1: trimleft  2: trimright  3: trim */
            int i; /* Loop counter */
            int[] aLen = null; /* Length of each character in zCharSet */
            byte[][] azChar = null; /* Individual characters in zCharSet */
            int nChar = 0; /* Number of characters in zCharSet */
            byte[] zBytes = null;
            byte[] zBlob = null;

            if (sqlite3_value_type(argv[0]) == FundamentalDataType.SQLITE_NULL)
            {
                return;
            }
            zIn = sqlite3_value_text(argv[0]);
            if (zIn == null) return;
            nIn = sqlite3_value_bytes(argv[0]);
            zBlob = sqlite3_value_blob(argv[0]);
            //Debug.Assert( zIn == sqlite3_value_text( argv[0] ) );
            if (argc == 1)
            {
                var lenOne = new[] {1};
                var azOne = new[] {(byte) ' '}; //static unsigned char * const azOne[] = { (byte*)" " };
                nChar = 1;
                aLen = lenOne;
                azChar = new byte[1][];
                azChar[0] = azOne;
                zCharSet = null;
            }
            else if ((zCharSet = sqlite3_value_text(argv[1])) == null)
            {
                return;
            }
            else
            {
                zBytes = sqlite3_value_blob(argv[1]);
                int iz = 0;
                for (nChar = 0; iz < zBytes.Length; nChar++)
                {
                    SQLITE_SKIP_UTF8(zBytes, ref iz);
                }
                if (nChar > 0)
                {
                    azChar = new byte[nChar][]; //contextMalloc(context, ((long)nChar)*(sizeof(char*)+1));
                    if (azChar == null)
                    {
                        return;
                    }
                    aLen = new int[nChar];

                    int iz0 = 0;
                    int iz1 = 0;
                    for (int ii = 0; ii < nChar; ii++)
                    {
                        SQLITE_SKIP_UTF8(zBytes, ref iz1);
                        aLen[ii] = iz1 - iz0;
                        azChar[ii] = new byte[aLen[ii]];
                        Buffer.BlockCopy(zBytes, iz0, azChar[ii], 0, azChar[ii].Length);
                        iz0 = iz1;
                    }
                }
            }
            if (nChar > 0)
            {
                flags = (int) sqlite3_user_data(context); // flags = SQLITE_PTR_TO_INT(sqlite3_user_data(context));
                if ((flags & 1) != 0)
                {
                    while (nIn > 0)
                    {
                        int len = 0;
                        for (i = 0; i < nChar; i++)
                        {
                            len = aLen[i];
                            if (len <= nIn && Custom.Memcmp(zBlob, izIn, azChar[i], len) == 0) break;
                        }
                        if (i >= nChar) break;
                        izIn += len;
                        nIn -= len;
                    }
                }
                if ((flags & 2) != 0)
                {
                    while (nIn > 0)
                    {
                        int len = 0;
                        for (i = 0; i < nChar; i++)
                        {
                            len = aLen[i];
                            if (len <= nIn && Custom.Memcmp(zBlob, izIn + nIn - len, azChar[i], len) == 0) break;
                        }
                        if (i >= nChar) break;
                        nIn -= len;
                    }
                }
                if (zCharSet != null)
                {
                    //Malloc.sqlite3_free( ref  azChar );
                }
            }
            var sb = new StringBuilder(nIn);
            for (i = 0; i < nIn; i++) sb.Append((char) zBlob[izIn + i]);
            sqlite3_result_text(context, sb.ToString(), nIn, Const.SQLITE_TRANSIENT);
        }

        /* IMP: R-25361-16150 This function is omitted from SQLite by default. It
    ** is only available if the SQLITE_SOUNDEX compile-time option is used
    ** when SQLite is built.
    */
#if SQLITE_SOUNDEX
/*
** Compute the soundex encoding of a word.
**
** IMP: R-59782-00072 The soundex(X) function returns a string that is the
** soundex encoding of the string X. 
*/
static void soundexFunc(
sqlite3_context context,
int argc,
sqlite3_value[] argv
)
{
Debug.Assert(false); // TODO -- func_c
char zResult[8];
const byte *zIn;
int i, j;
static const unsigned char iCode[] = {
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 1, 2, 3, 0, 1, 2, 0, 0, 2, 2, 4, 5, 5, 0,
1, 2, 6, 2, 3, 0, 1, 0, 2, 0, 2, 0, 0, 0, 0, 0,
0, 0, 1, 2, 3, 0, 1, 2, 0, 0, 2, 2, 4, 5, 5, 0,
1, 2, 6, 2, 3, 0, 1, 0, 2, 0, 2, 0, 0, 0, 0, 0,
};
Debug.Assert( argc==1 );
zIn = (byte*)sqlite3_value_text(argv[0]);
if( zIn==0 ) zIn = (byte*)"";
for(i=0; zIn[i] && !sqlite3Isalpha(zIn[i]); i++){}
if( zIn[i] ){
byte prevcode = iCode[zIn[i]&0x7f];
zResult[0] = sqlite3Toupper(zIn[i]);
for(j=1; j<4 && zIn[i]; i++){
int code = iCode[zIn[i]&0x7f];
if( code>0 ){
if( code!=prevcode ){
prevcode = code;
zResult[j++] = code + '0';
}
}else{
prevcode = 0;
}
}
while( j<4 ){
zResult[j++] = '0';
}
zResult[j] = 0;
sqlite3_result_text(context, zResult, 4, Const.SQLITE_TRANSIENT);
}else{
/* IMP: R-64894-50321 The string "?000" is returned if the argument
** is NULL or contains no ASCII alphabetic characters. */
sqlite3_result_text(context, "?000", 4, Const.SQLITE_STATIC);
}
}
#endif
        //* SQLITE_SOUNDEX */

#if ! SQLITE_OMIT_LOAD_EXTENSION
        /*
** A function that loads a shared-library extension then returns NULL.
*/

        private static void loadExt(
            sqlite3_context context,
            int argc,
            sqlite3_value[] argv
            )
        {
            string zFile = sqlite3_value_text(argv[0]);
            string zProc;
            sqlite3 db = sqlite3_context_db_handle(context);
            string zErrMsg = "";

            if (argc == 2)
            {
                zProc = sqlite3_value_text(argv[1]);
            }
            else
            {
                zProc = "";
            }
            if (zFile != null && sqlite3_load_extension(db, zFile, zProc, ref zErrMsg) != 0)
            {
                sqlite3_result_error(context, zErrMsg, -1);
                MemPool.DbFree(db, ref zErrMsg);
            }
        }
#endif


        /*
    ** Routines used to compute the sum, average, and total.
    **
    ** The SUM() function follows the (broken) SQL standard which means
    ** that it returns NULL if it sums over no inputs.  TOTAL returns
    ** 0.0 in that case.  In addition, TOTAL always returns a float where
    ** SUM might return an integer if it never encounters a floating point
    ** value.  TOTAL never fails, but SUM might through an exception if
    ** it overflows an integer.
    */

        private static void sumStep(
            sqlite3_context context,
            int argc,
            sqlite3_value[] argv
            )
        {
            SumCtx p;

            int type;
            Debug.Assert(argc == 1);
            Helper.UNUSED_PARAMETER(argc);
            Mem pMem = sqlite3_aggregate_context(context, 1); //sizeof(*p));
            if (pMem._SumCtx == null) pMem._SumCtx = new SumCtx();
            p = pMem._SumCtx;
            if (p.Context == null) p.Context = pMem;
            type = sqlite3_value_numeric_type(argv[0]);
            if (p != null && type != FundamentalDataType.SQLITE_NULL)
            {
                p.cnt++;
                if (type == FundamentalDataType.SQLITE_INTEGER)
                {
                    long v = sqlite3_value_int64(argv[0]);
                    p.rSum += v;
                    if (!(p.approx | p.overflow != 0))
                    {
                        long iNewSum = p.iSum + v;
                        var s1 = (int) (p.iSum >> (sizeof (long)*8 - 1));
                        var s2 = (int) (v >> (sizeof (long)*8 - 1));
                        var s3 = (int) (iNewSum >> (sizeof (long)*8 - 1));
                        p.overflow = ((s1 & s2 & ~s3) | (~s1 & ~s2 & s3)) != 0 ? 1 : 0;
                        p.iSum = iNewSum;
                    }
                }
                else
                {
                    p.rSum += sqlite3_value_double(argv[0]);
                    p.approx = true;
                }
            }
        }

        private static void sumFinalize(sqlite3_context context)
        {
            SumCtx p = null;
            Mem pMem = sqlite3_aggregate_context(context, 0);
            if (pMem != null) p = pMem._SumCtx;
            if (p != null && p.cnt > 0)
            {
                if (p.overflow != 0)
                {
                    sqlite3_result_error(context, "integer overflow", -1);
                }
                else if (p.approx)
                {
                    sqlite3_result_double(context, p.rSum);
                }
                else
                {
                    sqlite3_result_int64(context, p.iSum);
                }
                p.cnt = 0; // Reset for C#
            }
        }

        private static void avgFinalize(sqlite3_context context)
        {
            SumCtx p = null;
            Mem pMem = sqlite3_aggregate_context(context, 0);
            if (pMem != null) p = pMem._SumCtx;
            if (p != null && p.cnt > 0)
            {
                sqlite3_result_double(context, p.rSum/p.cnt);
            }
        }

        private static void totalFinalize(sqlite3_context context)
        {
            SumCtx p = null;
            Mem pMem = sqlite3_aggregate_context(context, 0);
            if (pMem != null) p = pMem._SumCtx;
            /* (double)0 In case of SQLITE_OMIT_FLOATING_POINT... */
            sqlite3_result_double(context, p != null ? p.rSum : 0);
        }


        /*
    ** Routines to implement the count() aggregate function.
    */

        private static void countStep(
            sqlite3_context context,
            int argc,
            sqlite3_value[] argv
            )
        {
            var p = new CountCtx();
            p.Context = sqlite3_aggregate_context(context, 1); //sizeof(*p));
            if ((argc == 0 || FundamentalDataType.SQLITE_NULL != sqlite3_value_type(argv[0])) && p.Context != null)
            {
                p.n++;
            }
#if !SQLITE_OMIT_DEPRECATED
/* The sqlite3_aggregate_count() function is deprecated.  But just to make
** sure it still operates correctly, verify that its count agrees with our
** internal count when using count(*) and when the total count can be
** expressed as a 32-bit integer. */
Debug.Assert( argc == 1 || p == null || p.n > 0x7fffffff
|| p.n == sqlite3_aggregate_count( context ) );
#endif
        }

        private static void countFinalize(sqlite3_context context)
        {
            var p = new CountCtx();
            p.Context = sqlite3_aggregate_context(context, 0);
            sqlite3_result_int64(context, p != null ? p.n : 0);
        }

        /*
    ** Routines to implement min() and max() aggregate functions.
    */

        private static void minmaxStep(
            sqlite3_context context,
            int NotUsed,
            sqlite3_value[] argv
            )
        {
            Mem pArg = argv[0];
            Mem pBest;
            Helper.UNUSED_PARAMETER(NotUsed);

            if (sqlite3_value_type(argv[0]) == FundamentalDataType.SQLITE_NULL) return;
            pBest = sqlite3_aggregate_context(context, 1); //sizeof(*pBest));
            //if ( pBest == null ) return;

            if (pBest.flags != 0)
            {
                bool max;
                int cmp;
                CollSeq pColl = sqlite3GetFuncCollSeq(context);
                /* This step function is used for both the min() and max() aggregates,
        ** the only difference between the two being that the sense of the
        ** comparison is inverted. For the max() aggregate, the
        ** sqlite3_context_db_handle() function returns (void *)-1. For min() it
        ** returns (void *)db, where db is the sqlite3* database pointer.
        ** Therefore the next statement sets variable 'max' to 1 for the max()
        ** aggregate, or 0 for min().
        */
                max = sqlite3_context_db_handle(context) != null && (int) sqlite3_user_data(context) != 0;
                cmp = sqlite3MemCompare(pBest, pArg, pColl);
                if ((max && cmp < 0) || (!max && cmp > 0))
                {
                    sqlite3VdbeMemCopy(pBest, pArg);
                }
            }
            else
            {
                sqlite3VdbeMemCopy(pBest, pArg);
            }
        }

        private static void minMaxFinalize(sqlite3_context context)
        {
            sqlite3_value pRes;
            pRes = sqlite3_aggregate_context(context, 0);
            if (pRes != null)
            {
                if (UnitTest.ALWAYS(pRes.flags != 0))
                {
                    sqlite3_result_value(context, pRes);
                }
                sqlite3VdbeMemRelease(pRes);
            }
        }

        /*
    ** group_concat(EXPR, ?SEPARATOR?)
    */

        private static void groupConcatStep(
            sqlite3_context context,
            int argc,
            sqlite3_value[] argv
            )
        {
            string zVal;
            //StrAccum pAccum;
            string zSep;
            int nVal, nSep;
            Debug.Assert(argc == 1 || argc == 2);
            if (sqlite3_value_type(argv[0]) == FundamentalDataType.SQLITE_NULL) return;
            Mem pMem = sqlite3_aggregate_context(context, 1); //sizeof(*pAccum));
            if (pMem._StrAccum.zBase == null) pMem._StrAccum = new StrAccum(100);
            //pAccum = pMem._StrAccum;
            if (pMem._StrAccum.Context == null) pMem._StrAccum.Context = pMem;
            if (pMem._StrAccum.zBase != null)
            {
                sqlite3 db = sqlite3_context_db_handle(context);
                int firstTerm = pMem._StrAccum.useMalloc == 0 ? 1 : 0;
                pMem._StrAccum.useMalloc = 1;
                pMem._StrAccum.mxAlloc = db.aLimit[LimitCategory.SQLITE_LIMIT_LENGTH];
                if (0 == firstTerm)
                {
                    if (argc == 2)
                    {
                        zSep = sqlite3_value_text(argv[1]);
                        nSep = sqlite3_value_bytes(argv[1]);
                    }
                    else
                    {
                        zSep = ",";
                        nSep = 1;
                    }
                    Print.StrAccumAppend(pMem._StrAccum, zSep, nSep);
                }
                zVal = sqlite3_value_text(argv[0]);
                nVal = sqlite3_value_bytes(argv[0]);
                Print.StrAccumAppend(pMem._StrAccum, zVal, nVal);
            }
        }

        private static void groupConcatFinalize(sqlite3_context context)
        {
            //StrAccum pAccum = null;
            Mem pMem = sqlite3_aggregate_context(context, 0);
            if (pMem != null)
            {
                if (pMem._StrAccum.zBase == null) pMem._StrAccum = new StrAccum(100);
                StrAccum pAccum = pMem._StrAccum;
                //}
                //if ( pAccum != null )
                //{
                if (pAccum.tooBig != 0)
                {
                    sqlite3_result_error_toobig(context);
                }
                    //else if ( pAccum.mallocFailed != 0 )
                    //{
                    //  sqlite3_result_error_nomem( context );
                    //}
                else
                {
                    sqlite3_result_text(context, Print.StrAccumFinish(pAccum), -1,
                                        null); //Malloc.sqlite3_free );
                }
            }
        }

        /*
    ** This function registered all of the above C functions as SQL
    ** functions.  This should be the only routine in this file with
    ** external linkage.
    */

        public struct sFuncs
        {
            public byte argType; /* 1: 0, 2: 1, 3: 2,...  N:  N-1. */
            public byte eTextRep; /* 1: UTF-16.  0: UTF-8 */
            public sbyte nArg;
            public byte needCollSeq;
            public dxFunc xFunc; //(sqlite3_context*,int,sqlite3_value **);
            public string zName;

            // Constructor
            public sFuncs(string zName, sbyte nArg, byte argType, byte eTextRep, byte needCollSeq, dxFunc xFunc)
            {
                this.zName = zName;
                this.nArg = nArg;
                this.argType = argType;
                this.eTextRep = eTextRep;
                this.needCollSeq = needCollSeq;
                this.xFunc = xFunc;
            }
        };

        public struct sAggs
        {
            public byte argType;
            public sbyte nArg;
            public byte needCollSeq;
            public dxFinal xFinalize; //(sqlite3_context*);
            public dxStep xStep; //(sqlite3_context*,int,sqlite3_value**);
            public string zName;
            // Constructor
            public sAggs(string zName, sbyte nArg, byte argType, byte needCollSeq, dxStep xStep, dxFinal xFinalize)
            {
                this.zName = zName;
                this.nArg = nArg;
                this.argType = argType;
                this.needCollSeq = needCollSeq;
                this.xStep = xStep;
                this.xFinalize = xFinalize;
            }
        }

        private static void sqlite3RegisterBuiltinFunctions(sqlite3 db)
        {
#if !SQLITE_OMIT_ALTERTABLE
            Alter.AlterFunctions(db);
#endif
            ////if ( 0 == db.mallocFailed )
            {
                int rc = sqlite3_overload_function(db, "MATCH", 2);
                Debug.Assert(rc == StatusCode.SQLITE_NOMEM || rc == StatusCode.SQLITE_OK);
                if (rc == StatusCode.SQLITE_NOMEM)
                {
                    ////        db.mallocFailed = 1;
                }
            }
        }

        /*
    ** Set the LIKEOPT flag on the 2-argument function with the given name.
    */

        private static void setLikeOptFlag(sqlite3 db, string zName, int flagVal)
        {
            FuncDef pDef;
            pDef = Callback.FindFunction(db, zName, Utility.Sqlite3Strlen30(zName),
                                       2, Const.SQLITE_UTF8, 0);
            if (UnitTest.ALWAYS(pDef != null))
            {
                pDef.flags = (byte) flagVal;
            }
        }

        /*
    ** Register the built-in LIKE and GLOB functions.  The caseSensitive
    ** parameter determines whether or not the LIKE operator is case
    ** sensitive.  GLOB is always case sensitive.
    */

        private static void sqlite3RegisterLikeFunctions(sqlite3 db, int caseSensitive)
        {
            compareInfo pInfo;
            if (caseSensitive != 0)
            {
                pInfo = likeInfoAlt;
            }
            else
            {
                pInfo = likeInfoNorm;
            }
            sqlite3CreateFunc(db, "like", 2, Const.SQLITE_ANY, pInfo, likeFunc, null, null);
            sqlite3CreateFunc(db, "like", 3, Const.SQLITE_ANY, pInfo, likeFunc, null, null);
            sqlite3CreateFunc(db, "glob", 2, Const.SQLITE_ANY,
                              globInfo, likeFunc, null, null);
            setLikeOptFlag(db, "glob", FuncDefFlag.SQLITE_FUNC_LIKE | FuncDefFlag.SQLITE_FUNC_CASE);
            setLikeOptFlag(db, "like",
                           caseSensitive != 0 ? (FuncDefFlag.SQLITE_FUNC_LIKE | FuncDefFlag.SQLITE_FUNC_CASE) : FuncDefFlag.SQLITE_FUNC_LIKE);
        }

        /*
    ** pExpr points to an expression which implements a function.  If
    ** it is appropriate to apply the LIKE optimization to that function
    ** then set aWc[0] through aWc[2] to the wildcard characters and
    ** return TRUE.  If the function is not a LIKE-style function then
    ** return FALSE.
    */

        private static bool sqlite3IsLikeFunction(sqlite3 db, Expr pExpr, ref bool pIsNocase, char[] aWc)
        {
            FuncDef pDef;
            if (pExpr.op != TokenKeyword.TK_FUNCTION
                || null == pExpr.x.pList
                || pExpr.x.pList.nExpr != 2
                )
            {
                return false;
            }
            Debug.Assert(!Helper.ExprHasProperty(pExpr, ExprFlag.EP_xIsSelect));
            pDef = Callback.FindFunction(db, pExpr.u.zToken, Utility.Sqlite3Strlen30(pExpr.u.zToken),
                                       2, Const.SQLITE_UTF8, 0);
            if (UnitTest.NEVER(pDef == null) || (pDef.flags & FuncDefFlag.SQLITE_FUNC_LIKE) == 0)
            {
                return false;
            }

            /* The memcpy() statement assumes that the wildcard characters are
      ** the first three statements in the compareInfo structure.  The
      ** Debug.Asserts() that follow verify that assumption
      */
            //memcpy( aWc, pDef.pUserData, 3 );
            aWc[0] = ((compareInfo) pDef.pUserData).matchAll;
            aWc[1] = ((compareInfo) pDef.pUserData).matchOne;
            aWc[2] = ((compareInfo) pDef.pUserData).matchSet;
            // Debug.Assert((char*)&likeInfoAlt == (char*)&likeInfoAlt.matchAll);
            // Debug.Assert(&((char*)&likeInfoAlt)[1] == (char*)&likeInfoAlt.matchOne);
            // Debug.Assert(&((char*)&likeInfoAlt)[2] == (char*)&likeInfoAlt.matchSet);
            pIsNocase = (pDef.flags & FuncDefFlag.SQLITE_FUNC_CASE) == 0;
            return true;
        }

        /*
    ** All all of the FuncDef structures in the aBuiltinFunc[] array above
    ** to the global function hash table.  This occurs at start-time (as
    ** a consequence of calling sqlite3_initialize()).
    **
    ** After this routine runs
    */

        private static void sqlite3RegisterGlobalFunctions()
        {
            /*
      ** The following array holds FuncDef structures for all of the functions
      ** defined in this file.
      **
      ** The array cannot be constant since changes are made to the
      ** FuncDef.pHash elements at start-time.  The elements of this array
      ** are read-only after initialization is complete.
      */
            FuncDef[] aBuiltinFunc = {
                                         FUNCTION("ltrim", 1, 1, 0, trimFunc),
                                         FUNCTION("ltrim", 2, 1, 0, trimFunc),
                                         FUNCTION("rtrim", 1, 2, 0, trimFunc),
                                         FUNCTION("rtrim", 2, 2, 0, trimFunc),
                                         FUNCTION("trim", 1, 3, 0, trimFunc),
                                         FUNCTION("trim", 2, 3, 0, trimFunc),
                                         FUNCTION("min", -1, 0, 1, minmaxFunc),
                                         FUNCTION("min", 0, 0, 1, null),
                                         AGGREGATE("min", 1, 0, 1, minmaxStep, minMaxFinalize),
                                         FUNCTION("max", -1, 1, 1, minmaxFunc),
                                         FUNCTION("max", 0, 1, 1, null),
                                         AGGREGATE("max", 1, 1, 1, minmaxStep, minMaxFinalize),
                                         FUNCTION("typeof", 1, 0, 0, typeofFunc),
                                         FUNCTION("length", 1, 0, 0, lengthFunc),
                                         FUNCTION("substr", 2, 0, 0, substrFunc),
                                         FUNCTION("substr", 3, 0, 0, substrFunc),
                                         FUNCTION("abs", 1, 0, 0, absFunc),
#if !SQLITE_OMIT_FLOATING_POINT
                                         FUNCTION("round", 1, 0, 0, roundFunc),
                                         FUNCTION("round", 2, 0, 0, roundFunc),
#endif
                                         FUNCTION("upper", 1, 0, 0, upperFunc),
                                         FUNCTION("lower", 1, 0, 0, lowerFunc),
                                         FUNCTION("coalesce", 1, 0, 0, null),
                                         FUNCTION("coalesce", 0, 0, 0, null),
/*  FUNCTION(coalesce,          -1, 0, 0, ifnullFunc       ), */
// use versionFunc here just for a dummy placeholder
                                         new FuncDef(-1, Const.SQLITE_UTF8, FuncDefFlag.SQLITE_FUNC_COALESCE, null, null, versionFunc,
                                                     null, null, "coalesce", null),
                                         FUNCTION("hex", 1, 0, 0, hexFunc),
/*  FUNCTION(ifnull,             2, 0, 0, ifnullFunc       ), */
// use versionFunc here just for a dummy placeholder
                                         new FuncDef(2, Const.SQLITE_UTF8, FuncDefFlag.SQLITE_FUNC_COALESCE, null, null, versionFunc, null,
                                                     null, "ifnull", null),
                                         FUNCTION("random", 0, 0, 0, randomFunc),
                                         FUNCTION("randomblob", 1, 0, 0, randomBlob),
                                         FUNCTION("nullif", 2, 0, 1, nullifFunc),
                                         FUNCTION("sqlite_version", 0, 0, 0, versionFunc),
                                         FUNCTION("sqlite_source_id", 0, 0, 0, sourceidFunc),
#if !SQLITE_OMIT_COMPILEOPTION_DIAGS
                                         FUNCTION("sqlite_compileoption_used", 1, 0, 0, compileoptionusedFunc),
                                         FUNCTION("sqlite_compileoption_get", 1, 0, 0, compileoptiongetFunc),
#endif
                                         //* SQLITE_OMIT_COMPILEOPTION_DIAGS */
                                         FUNCTION("quote", 1, 0, 0, quoteFunc),
                                         FUNCTION("last_insert_rowid", 0, 0, 0, last_insert_rowid),
                                         FUNCTION("changes", 0, 0, 0, changes),
                                         FUNCTION("total_changes", 0, 0, 0, total_changes),
                                         FUNCTION("replace", 3, 0, 0, replaceFunc),
                                         FUNCTION("zeroblob", 1, 0, 0, zeroblobFunc),
#if SQLITE_SOUNDEX
FUNCTION("soundex",            1, 0, 0, soundexFunc      ),
#endif
#if !SQLITE_OMIT_LOAD_EXTENSION
                                         FUNCTION("load_extension", 1, 0, 0, loadExt),
                                         FUNCTION("load_extension", 2, 0, 0, loadExt),
#endif
                                         AGGREGATE("sum", 1, 0, 0, sumStep, sumFinalize),
                                         AGGREGATE("total", 1, 0, 0, sumStep, totalFinalize),
                                         AGGREGATE("avg", 1, 0, 0, sumStep, avgFinalize),
/*AGGREGATE("count",             0, 0, 0, countStep,       countFinalize  ), */
/* AGGREGATE(count,             0, 0, 0, countStep,       countFinalize  ), */
                                         new FuncDef(0, Const.SQLITE_UTF8, FuncDefFlag.SQLITE_FUNC_COUNT, null, null, null, countStep,
                                                     countFinalize, "count", null),
                                         AGGREGATE("count", 1, 0, 0, countStep, countFinalize),
                                         AGGREGATE("group_concat", 1, 0, 0, groupConcatStep, groupConcatFinalize),
                                         AGGREGATE("group_concat", 2, 0, 0, groupConcatStep, groupConcatFinalize),
                                         LIKEFUNC("glob", 2, globInfo, FuncDefFlag.SQLITE_FUNC_LIKE | FuncDefFlag.SQLITE_FUNC_CASE),
#if SQLITE_CASE_SENSITIVE_LIKE
LIKEFUNC("like", 2, likeInfoAlt, FuncDefFlag.SQLITE_FUNC_LIKE|FuncDefFlag.SQLITE_FUNC_CASE),
LIKEFUNC("like", 3, likeInfoAlt, FuncDefFlag.SQLITE_FUNC_LIKE|FuncDefFlag.SQLITE_FUNC_CASE),
#else
                                         LIKEFUNC("like", 2, likeInfoNorm, FuncDefFlag.SQLITE_FUNC_LIKE),
                                         LIKEFUNC("like", 3, likeInfoNorm, FuncDefFlag.SQLITE_FUNC_LIKE),
#endif
                                     };
            int i;
#if SQLITE_OMIT_WSD
FuncDefHash pHash = GLOBAL( FuncDefHash, Global.Sqlite3GlobalFunctions );
FuncDef[] aFunc = (FuncDef[])GLOBAL( FuncDef, aBuiltinFunc );
#else
            FuncDefHash pHash = Global.Sqlite3GlobalFunctions;
            FuncDef[] aFunc = aBuiltinFunc;
#endif
            for (i = 0; i < Utility.ArraySize(aBuiltinFunc); i++)
            {
                Callback.FuncDefInsert(pHash, aFunc[i]);
            }
            sqlite3RegisterDateTimeFunctions();
        }
    }
}